#pragma once
#include <iostream>
#include <cassert>
#include <cstdlib>
#include <string.h>
using namespace std;
namespace cc
{
    class string
    {
    friend istream& operator>>(istream& in,string& s);
    public:
    //迭代器
    typedef char* iterator;
    typedef const char* const_iterator;
        string(const char *str = "\0")
            : _str(new char[strlen(str)+1])
            , _capacity(strlen(str))
            , _size(_capacity)
        {
            strcpy(_str,str);
        }
        string(const string& d)
            : _str(nullptr)
        {
            string tem(d._str);
            swap(tem);
        }
        ~string()
        {
            delete[] _str;
            _str=nullptr;
            _capacity=_size=0;
        }
        string& operator=(string d)
        {
            swap(d);
            return *this;
        }
        iterator begin()
        {
            return _str;
        }
        iterator end()
        {
            return _str+_size;
        }
        const_iterator begin()const
        {
            return _str;
        }
        const_iterator end()const
        {
            return _str+_size;
        }
        void swap(string& d)
        {
            std::swap(_str,d._str);
            std::swap(_capacity,d._capacity);
            std::swap(_size,d._size);
        }
        size_t capacity()const
        {
            return (size_t)_capacity;
        }
        size_t size()const
        {
            return (size_t)_size;
        }
        char& operator[](const int& x)const
        {
            assert(x<(int)size());
            return *(_str+x);
        }
        char* c_str()const
        {
            return _str;
        }
        void resize(size_t n,const char* str="\0")
        {
            _size=n;
            for(size_t i=0;i<_size;i++)
                _str[i]=str[i];
        }
        void reserve(size_t n)
        {
            if(_str==nullptr)
            {
                _str=new char[5];
                _capacity=4;
                _size=4;
            }
            else if(n>capacity())
            {
                char *tem=new char[n];
                strcpy(tem,_str);
                delete[] _str;
                _str=tem;
                _capacity=strlen(_str);
                _size=_capacity;
            }
        }
        //运算符重载
        bool operator==(const string& d)const;
        bool operator<=(const string& d)const;
        bool operator!=(const string& d)const;
        //......
    private:
        char *_str;
        int _capacity;
        int _size;
        //此数组的作用类似于是缓冲区
        //char _buf[15];
    };
    //重载<<不能用友元函数
    ostream& operator<<(ostream& out,const string& s)
    {
        size_t i=0;
        for(i=0;i<s.size();i++)
            out<<s[i];
        return out;
    }
    //方法一：
    // istream& operator>>(istream& in,const string& s)
    // {
    //     char ch;
    //     ch=in.get();
    //     //这里最好加上一个缓冲区(缓冲区用数组来代替，目的是提高效率)
    //     while(ch!=' '&&ch!='\n')
    //     {
    //         //s+=ch;
    //         ch=in.get();
    //     }
    //     return in;
    // }
    //方法二：
    istream& operator>>(istream& in,string& s)
    {
        in>>s._str;
        return in;
    }
}